package seqlist;

import java.util.Arrays;

/**
 * 基于数组的顺序表
 */
public class MyArray {
    // 存储元素仍然还在数组中存储
    private int[] data;
    // 当前动态数组中实际存储的元素个数
    private int size;
    public MyArray() {
        data = new int[10];
    }
    /**
     * @param capacity 传入的数组大小
     */
    public MyArray(int capacity) {
        data = new int[capacity];
    }

    public void addFirst(int value) {
        addIndex(0,value);
    }

    /**
     * 在数组的尾部插入
     * @param value 待插入的新元素值
     */
    public void addLast(int value) {
        addIndex(size,value);
    }
    /**
     * 在数组的任意位置插入
     * @param index 传入的索引值
     * @param value 要插入的新元素
     */
    public void addIndex(int index,int value) {
        // 判断index的合法性
        if (index < 0 || index > size) {
            System.err.println("add index illegal!");
            return;
        }
        // 判断数组满
        if (size == data.length) {
            grow();
        }
        // 将index位置空出来
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = value;
        size++;
    }

    /**
     * 在数组中查找value值对应的索引下标
     * @param value
     * @return
     */
    public int getByValue(int value) {
        // 遍历数组
        for (int i = 0; i < size; i++) {
            if (data[i] == value) {
                return i;
            }
        }
        // 此时循环走完还没找到元素，value不存在
        return -1;
    }

    /**
     * 根据索引查询元素
     * @param index 索引值
     * @return
     */
    public int get(int index) {
        // 判断合法性
        if (index < 0 || index >= size) {
            System.err.println("get index illegal!");
            return -1;
        }
        return data[index];
    }

    /**
     * 将指定索引位置元素修改为newValue，返回修改前的元素值
     * @param index
     * @param newValue
     * @return
     */
    public int set(int index,int newValue) {
        // 判断合法
        if (index < 0 || index >= size) {
            System.err.println("set index illegal!");
            return -1;
        }
        int oldValue = data[index];
        data[index] = newValue;
        return oldValue;
    }

    /**
     * 删除指定索引位置的元素
     * @param index
     */
    public void removeIndex(int index) {
        if (index < 0 || index >= size) {
            System.err.println("remove index illegal!");
            return;
        }
        // 当size == data.length
        for (int i = index;i < size - 1;i++) {
            data[i] = data[i + 1];
        }
        size --;
        data[size] = 0;
    }

    public void removeValueOnce(int value) {
        for (int i = 0; i < size; i++) {
            if (data[i] == value) {
                // 此时i对应的索引是第一个值为value的节点
                removeIndex(i);
                return;
            }
        }
    }
    
    public void removeAllValue(int value) {
        for (int i = 0; i < size; i++) {
            while (i != size && data[i] == value) {
                removeIndex(i);
            }
        }
    }

    public void removeFirst() {
        removeIndex(0);
    }

    public void removeLast() {
        removeIndex(size - 1);
    }

    public boolean contains(int value) {
        int index = getByValue(value);
        return index != -1;
    }
    
    public String toString() {
        String ret = "[";
        // 遍历data数组
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if (i != size - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

    private void grow() {
        int[] newData = Arrays.copyOf(this.data,this.data.length << 1);
        this.data = newData;
    }
}
